package com.sk.ccflower.lib.commonUtils;


import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class FileUtil{
	
    public FileUtil(){
        
    }

    public boolean isDirectory(String path){
        return new File(path).isDirectory();
    }


    public String[] readAllFileName( String path ) throws Exception{
        File f=new File( path );
        if( f.isDirectory() ){
            return f.list();
        }
        return new String[0];
    }



    /**
     * 주어진 디렉토리 내에서 파일 경로 검색
     * @param _dir: 검색 대상 디렉토리
     * @param _suffix: 파일 suffix
     * @param _isSort: 파일명 sorting
     * @return
     * @throws Exception
     */
    public static ArrayList<File> getFiles (String _dir, String _suffix, boolean _isSort) throws Exception
    {
        return getFiles(_dir, _suffix, _isSort, true);
    }

    /**
     * 주어진 디렉토리 내에서 파일 경로 검색
     * @param _dir: 검색 대상 디렉토리
     * @param _suffix: 파일 suffix
     * @param _isSort: 파일명 sorting
     * @param _sufficInclude: _suffix가 있는 경우 해당 _suffix를 포함한 것을 검색할지 포함하지 않은것을 검색할지 여부
     * @return
     * @throws Exception
     */
    public static ArrayList<File> getFiles (String _dir, String _suffix, boolean _isSort, boolean _suffixInclude) throws Exception
    {
        ArrayList<File> arr = new ArrayList<File>();

        File 	f = new File (_dir);
        File[] 	aFile = f.listFiles();

        if(aFile==null) return arr;

        int 	i = aFile.length;
        while (i-->0)
        {
            if (!aFile[i].isFile()) continue;
            if (_suffix != null) {
                if(_suffixInclude && !aFile[i].getName().endsWith(_suffix)) continue;
                else if(!_suffixInclude && aFile[i].getName().endsWith(_suffix)) continue;
            }
            arr.add(aFile[i]);
        }

        if (_isSort)
        {
            Comparator<Object> sort = new SortFileUtil(true);
            Collections.sort(arr, sort);
        }

        return arr;
    }

    public void clearAllFile( String path ) throws Exception{
        File f=new File( path );
        File[] tempF=null;
        if( f.isDirectory() ){
            tempF=f.listFiles();
            for( int i=0; i<tempF.length; i++ ){
                tempF[i].delete();
            }

        }
    }

    public String parentPath(String path){
        File f = new File(path);

        return f.getParentFile().getAbsolutePath();
    }

    public void renameFile( String fromFileName , String toFileName ) throws IOException {

        // target 폴더 생성
        //
        newFile(toFileName);

        // 파일 이동
        //
        File fromFile=new File( fromFileName );
        File toFile=new File( toFileName );
        if( this.existFile(toFileName) ){
            this.deleteFile(toFileName);
        }
        if( fromFile.renameTo( toFile )){
            this.deleteFile( fromFileName );
        }else{
            throw new IOException("Rename fail..." + fromFile + "->" + toFileName);
        }
    }

/**
     * fileName의 파일 내용을 읽어들인다.
     * @param fileName String
     * @throws IOExcepton
     * @return boolean
     */
    public String readFile( String fileName ) throws IOException{
        StringBuffer fileData=new StringBuffer();
        FileInputStream fi=null;
        InputStreamReader ir=null;
        BufferedReader bi=null;


        try{
            fi=new FileInputStream( fileName );
            ir=new InputStreamReader( fi );
            bi=new BufferedReader( ir );

            String str="";
            int i=0;

            while( true ){
                i++;
                str=bi.readLine();

                if( str==null ){
                    break;
                } else{
                    if( i==1 )
                        fileData.append( str );
                    else
                        fileData.append( "\r\n"+str );
                }
            }

        } catch( IOException e ){
            throw e;
        } finally{
            try{
                if( fi!=null )
                    fi.close();
                if( ir!=null )
                    ir.close();
                if( bi!=null )
                    bi.close();
            } catch( IOException e ){
            }
        }

        return fileData.toString();
    }

/**
     * 파일의 존재여부를 파악한다.<br><br>
     * @param filename String 파일명
     * @throws Exception
     * @return boolean 만약 존재한다면 true 를 리턴하고 그렇지 않으면 false를 리턴한다.
     */
    public boolean existFile( String filename ) throws IOException{
        File f=new File( filename );
        return f.exists();
    }

    public boolean deleteFile( String path ) throws IOException{
        boolean result = false;
        File f=new File( path );
        if( f.exists() ){
            result = f.delete();
        }
        return result;
    }


    public boolean writeFile( String fileName , String str ) throws IOException{
        if( !this.existFile(fileName )){
            this.newFile(fileName);
        }
        return this.writeFile( new File( fileName ) , str , false );
    }

/**
     * file에 쓰기
     * @param fileName String
     * @param str String
     */
    public boolean writeFile( File file , String str , boolean append ) throws IOException{

        FileWriter fw=null;
        boolean result=false;
        try{

            fw=new FileWriter( file , append );

            fw.write( str );
            fw.flush();
            result=true;
        } catch( IOException e ){
            throw e;
        } finally{
            try{
                fw.close();
            } catch( IOException ex ){
            }
        }

        return result;
    }





    public void newFile( String filename ) throws IOException{
        File f=new File( filename );
        File dir = f.getParentFile();
        if( !this.existFile(dir.getAbsolutePath())){
            this.newDir(dir.getAbsolutePath());
        }
        f.createNewFile();
    }

    public void newDir( String dirName ) throws IOException{
        File f=new File( dirName );
        if(!f.exists()) f.mkdirs();
    }

    public boolean copyFile( String fromFileName , String toFileName ) throws FileNotFoundException , IOException{

        boolean success = false;
        // target 폴더 생성
        //
        newFile(toFileName);

        // 파일 복사
        //
        File fromFile=new File( fromFileName );
        File toFile=new File( toFileName );
        InputStream is=null;
        OutputStream os=null;
        int n=0;
        byte buff[]=new byte[1024];
        try{
            is=new FileInputStream( fromFile );
            os=new FileOutputStream( toFile , false );

            while( true ){
                n=is.read( buff );
                if( n>0 ){
                    os.write( buff , 0 , n );
                    os.flush();
                    buff=new byte[1024];
                } else if( n<0 ){
                    break;
                }
            }
            success = true;
        } catch( FileNotFoundException ex ){
            throw ex;
        } catch( IOException ex ){
            throw ex;
        } finally{
            try{
                if( is!=null )
                    is.close();
                if( os!=null )
                    os.close();
            } catch( IOException ex1 ){
            }
        }
        return success;
    }
    
    public static void main(String[] argv)
    {
        
    }
}
